package com.ikas.ai.server.module.system.service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ikas.ai.server.error.BusinessException;
import com.ikas.ai.server.module.system.dao.RoleDAO;
import com.ikas.ai.server.module.system.model.Role;
import com.ikas.ai.server.module.system.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@Service
public class RoleService extends ServiceImpl<RoleDAO, Role> {

    @Autowired
    private UserService userService;
    @Autowired
    private RoleDAO roleDAO;
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 获取角色信息
     *
     * @param name
     * @return
     */
    public List<Role> getRoles(String name) {
        return roleDAO.getRoles(name, null);
    }

    /**
     * 获取角色信息
     * @param name
     * @param remark
     * @return
     */
    public List<Role> getRoles(String name, String remark) {
        return roleDAO.getRoles(name, remark);
    }

    /**
     * 根据角色ID获取角色
     * @param id
     * @return
     */
    public Role getRoleById(Long id) {
        return roleDAO.getRole(id);
    }

    /**
     * 根据角色名称获取角色
     * @param name
     * @return
     */
    public Role getRoleByName(String name) {
        return roleDAO.getRoleByName(name);
    }

    /**
     * 增加角色
     * @param role
     * @return
     */
    public int addRole(Role role,User user) {
        Role tmp = roleDAO.getRoleByName(role.getName());
        if (tmp != null) {
            throw new RuntimeException("用户角色已经存在");
        }
        role.setCreateTime(new Date());
        role.setCreatorId(user.getId());
        return roleDAO.insert(role);
    }

    /**
     * 修改角色
     * @param role
     * @return
     */
    public int updateRole(Role role) {
        Role tmp = roleDAO.getRoleByName(role.getName());
        if (tmp != null && tmp.getId().intValue() != role.getId().intValue()) {
            throw new RuntimeException("用户角色已经存在");
        }
        return roleDAO.updateRole(role);
    }

    /**
     * 删除角色
     * @param id
     * @return
     */
    @Transactional(rollbackFor = BusinessException.class)
    public int deleteRole(Long id) {
        if (id == 1) {
            throw new BusinessException("系统角色禁止删除");
        }
        // 删除角色以及角色关联的权限信息、角色关联的用户表信息
        int i = roleDAO.deleteRole(id);
        return i;
    }

    /**
     * 批量删除角色
     *
     * @param ids
     */
    public void deleteRoles(List<Long> ids) {
        if (ids != null && ids.size() > 0) {
            roleDAO.deleteRoles(ids);
        }
    }

    /**
     * 重新赋值权限(在比如:给一个角色临时添加一个权限,需要调用此方法刷新权限,否则还是没有刚赋值的权限)
     */
    @Async
    public void reloadAuthorizing(Long roleId) {
        Set<String> keys = new HashSet<>();
        //清除redis 授权缓存
        keys.addAll(redisTemplate.keys("shiro:cache:authorizationCache:*"));
        keys.addAll(redisTemplate.keys("shiro:cache:authenticationCache:*"));
        redisTemplate.delete(keys);

        List<User> userList = userService.selectByRoleId(roleId);
        userList.forEach(user -> {
            String userName = user.getUserName();
            userService.updateRedis(userName);
        });
    }
}
